﻿using PivotCollectionTools.BasicCollection;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;

namespace PivotCollectionTools.BasicCollection.Tests
{
    
    
    /// <summary>
    ///This is a test class for PivotCollectionTest and is intended
    ///to contain all PivotCollectionTest Unit Tests
    ///</summary>
    [TestClass()]
    public class PivotCollectionTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for Items
        ///</summary>
        public void ItemsTestHelper<T>()
            where T : class
        {
            PivotCollection<T> target = new PivotCollection<T>(); // TODO: Initialize to an appropriate value
            List<T> actual;
            actual = target.Items;
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void ItemsTest()
        {
            ItemsTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for CollectionName
        ///</summary>
        public void CollectionNameTestHelper<T>()
            where T : class
        {
            PivotCollection<T> target = new PivotCollection<T>(); // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            target.CollectionName = expected;
            actual = target.CollectionName;
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void CollectionNameTest()
        {
            CollectionNameTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for CleanOutput
        ///</summary>
        public void CleanOutputTestHelper<T>()
            where T : class
        {
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            PivotCollection<T>.CleanOutput = expected;
            actual = PivotCollection<T>.CleanOutput;
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        public void CleanOutputTest()
        {
            CleanOutputTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for WriteCollectionToFileSystem
        ///</summary>
        public void WriteCollectionToFileSystemTestHelper<T>()
            where T : class
        {
            PivotCollection<T> target = new PivotCollection<T>(); // TODO: Initialize to an appropriate value
            string fileName = string.Empty; // TODO: Initialize to an appropriate value
            target.WriteCollectionToFileSystem(fileName);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        [TestMethod()]
        public void WriteCollectionToFileSystemTest()
        {
            WriteCollectionToFileSystemTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for writeCollectionHead
        ///</summary>
        public void writeCollectionHeadTestHelper<T>()
            where T : class
        {
            PivotCollection_Accessor<T> target = new PivotCollection_Accessor<T>(); // TODO: Initialize to an appropriate value
            target.writeCollectionHead();
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        [TestMethod()]
        [DeploymentItem("PivotCollectionTools.BasicCollection.dll")]
        public void writeCollectionHeadTest()
        {
            writeCollectionHeadTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for GetName
        ///</summary>
        public void GetNameTestHelper<T>()
            where T : class
        {
            T item = null; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = PivotCollection_Accessor<T>.GetName(item);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        [DeploymentItem("PivotCollectionTools.BasicCollection.dll")]
        public void GetNameTest()
        {
            GetNameTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for GetImage
        ///</summary>
        public void GetImageTestHelper<T>()
            where T : class
        {
            T item = null; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = PivotCollection_Accessor<T>.GetImage(item);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        [DeploymentItem("PivotCollectionTools.BasicCollection.dll")]
        public void GetImageTest()
        {
            GetImageTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for GetHerf
        ///</summary>
        public void GetHerfTestHelper<T>()
            where T : class
        {
            T item = null; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = PivotCollection_Accessor<T>.GetHerf(item);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        [DeploymentItem("PivotCollectionTools.BasicCollection.dll")]
        public void GetHerfTest()
        {
            GetHerfTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for GetDescription
        ///</summary>
        public void GetDescriptionTestHelper<T>()
            where T : class
        {
            T item = null; // TODO: Initialize to an appropriate value
            string expected = string.Empty; // TODO: Initialize to an appropriate value
            string actual;
            actual = PivotCollection_Accessor<T>.GetDescription(item);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

        [TestMethod()]
        [DeploymentItem("PivotCollectionTools.BasicCollection.dll")]
        public void GetDescriptionTest()
        {
            GetDescriptionTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for cacheProperties
        ///</summary>
        public void cachePropertiesTestHelper<T>()
            where T : class
        {
            PivotCollection_Accessor<T> target = new PivotCollection_Accessor<T>(); // TODO: Initialize to an appropriate value
            target.cacheProperties();
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }

        [TestMethod()]
        [DeploymentItem("PivotCollectionTools.BasicCollection.dll")]
        public void cachePropertiesTest()
        {
            cachePropertiesTestHelper<GenericParameterHelper>();
        }

        /// <summary>
        ///A test for PivotCollection`1 Constructor
        ///</summary>
        public void PivotCollectionConstructorTestHelper<T>()
            where T : class
        {
            PivotCollection<T> target = new PivotCollection<T>();
            Assert.Inconclusive("TODO: Implement code to verify target");
        }

        [TestMethod()]
        public void PivotCollectionConstructorTest()
        {
            PivotCollectionConstructorTestHelper<GenericParameterHelper>();
        }
    }
}
